<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
</head>

<body>
    <script>
        // Promise.catch()方法
        // 处理 rejected 的情况，与 then 的第二个参数 onRejected 相同 
        // 返回值：返回一个 Promise 对象，状态默认为 fulfilled/resolved
        // 作用：可以捕获 catch 之前的 Promise Chain 中的任一错误（如果 Promise Chain 中的 then 没有处理的话）
        // new Promise((resolve, reject) => {
        //         resolve();
        //         // reject('第一步错误');
        //     })
        //     .then(() => {
        //         // console.log('登录成功')
        //         return new Promise((resolve, reject) => {
        //             reject('登录失败'); // 登陆失败
        //         })
        //     })
        //     .then(() => {
        //         console.log('是管理员')
        //     })
        //     .then(() => {
        //         console.log('拿到资源')
        //     }).catch(err => {
        //         console.log(err);
        //     }).then(() => {
        //         console.log('catch以后') // catch以后
        //     });

        // new Promise((resolve, reject) => {
        //         reject(2)
        //     })
        //     .then(() => {
        //         console.log(1);
        //     })
        //     .catch(
        //         (err) => {
        //             console.log(err); // 2
        //         }
        //     )
        //     .then(() => {
        //         return new Promise((resolve, reject) => {
        //             reject(22)
        //         })
        //     }).then(() => {
        //         console.log(11);
        //     }).catch(
        //         (err) => {
        //             console.log(err); // 22
        //         }
        //     )






        //            Promise的静态方法


        // Promise.all 方法
        // 多任务处理
        // 语法：Promise.all(iterable) 
        // 参数：iterable：包含多个 Promise 的迭代器对象，比如数组
        // 作用：当迭代器对象中的所有 Promise 状态都会 fulfilled/resolved 的时候，
        // 整体才是 fulfilled/resolved，否则就是 rejected
        // let p1 = new Promise((resolve, reject) => {
        //     setTimeout(() => {
        //         console.log(1) // 1
        //         resolve(10);
        //     }, 2000);
        // });
        // let p2 = new Promise((resolve, reject) => {
        //     setTimeout(() => {
        //         console.log(2) // 2
        //         resolve(20);
        //     }, 3000);
        // })
        // Promise.all([p1, p2]).then(arr => {
        //     console.log(3, arr); // 3 [10,20]
        // })



        // Promise.allSettled(iterable)
        // 参数：iterable: 一个可迭代的对象，例如数组，其中每个成员都是Promise。
        // 等到所有promises都已敲定（settled）
        // （每个promise都已兑现（fulfilled）或已拒绝（rejected））。
        // 返回一个promise，该promise在所有promise完成后完成。
        // 并带有一个对象数组，每个对象对应每个promise的结果。
        // const promise1 = Promise.resolve(3);
        // const promise2 = new Promise((resolve, reject) => setTimeout(reject, 100, 'foo'));
        // const promises = [promise1, promise2];

        // Promise.allSettled(promises).
        // then((results) => results.forEach((result) => console.log(result.status, result.value)));
        // 每个结果对象，都有一个 status 字符串。如果它的值为 fulfilled，则结果对象上存在一个 value 。
        // 如果值为 rejected，则存在一个 reason 。
        // value（或 reason ）反映了每个 promise 决议（或拒绝）的值。


        // ***setTimeout第三个参数的作用
        // var a = setTimeout((a, b, c) => {
        //     console.log(a, b, c)
        // }, 2000, "my", "name", "is starsion");


        // Promise.race方法
        // 多任务处理
        // 语法： Promise.race(iterable)
        // 参数： iterable： 包含多个 Promise 的迭代器对象， 比如数组
        // 作用： 当迭代器对象中的首个任务完成（ 可以是fulfilled / resolved， 
        // 也可能是 rejected） 就会调用， 并且状态取决于首个任务完成的状态
        // let p1 = new Promise((resolve, reject) => {
        //     setTimeout(() => {
        //         console.log(1)
        //         resolve(10);
        //     }, 2000);
        // })
        // let p2 = new Promise((resolve, reject) => {
        //     setTimeout(() => {
        //         console.log(2)
        //         resolve(20);
        //     }, 1000);
        // })
        // Promise.race([p1, p2]).then(arr => {
        //     console.log(3, arr);
        // })



        // Promise.resolve 方法 
        //         返回一个 fulfilled/resolved 状态的 Promise 对象
        // ● Promise.resolve(value) 
        // 返回值：返回一个包含value值的 fulfilled/resolved 状态的 Promise 对象 

        // ● Promise.resolve(promise)
        // 返回值：直接返回 promise 参数的 Promise 对象

        // ● Promise.resolve(thenable)
        // 返回值：返回 thenable 对象
        // 参数：    thenable：一个包含 then 方法的对象



        //         Promise.reject 方法 
        // 同 Promise.resolve 返回一个 rejected 状态的 Promise 对象
        // var p = new Promise((resolve, reject) => {
        //     resolve(1);
        // }).then(() => {
        //     console.log(1);
        //     // return Promise.reject(); // 不需要处理异步的业务，直接返回一个状态为reject的Promise对象
        //     // return Promise.resolve(); // 不需要处理异步的业务，直接返回一个状态为resolve的Promise对象
        // });



        // Promise.any()方法
        // Promise.any() 接收一个Promise可迭代对象，只要其中的一个 promise 成功，就返回那个已经成功的 promise 。
        // 如果可迭代对象中没有一个 promise 成功（即所有的 promises 都失败/拒绝），
        // 就返回一个失败的 promise 和AggregateError类型的实例，它是 Error 的一个子类，用于把单一的错误集合在一起。
        // 本质上，这个方法和Promise.all()是相反的。
        // 返回值：
        // 如果传入的参数是一个空的可迭代对象，则返回一个 已失败（already rejected） 状态的 Promise。
        // 如果传入的参数不包含任何 promise，则返回一个 异步完成 （asynchronously resolved）的 Promise。
        // 其他情况下都会返回一个处理中（pending） 的 Promise。 只要传入的迭代对象中的任何一个 promise 变成成功（resolve）状态，
        // 或者其中的所有的 promises 都失败，那么返回的 promise 就会 异步地（当调用栈为空时） 变成成功/失败（resolved/reject）状态。
        // const pErr = new Promise((resolve, reject) => {
        //     reject("总是失败");
        // });
        // const pSlow = new Promise((resolve, reject) => {
        //     setTimeout(resolve, 500, "最终完成");
        // });
        // const pFast = new Promise((resolve, reject) => {
        //     setTimeout(resolve, 100, "很快完成");
        // });
        // Promise.any([pErr, pSlow, pFast]).then((value) => {
        //     console.log(value);
        //     // pFast fulfils first
        // })

        // 期望输出: "很快完成"
    </script>
</body>

</html>